/* eslint-disable */
class AnyClass extends HTMLBRElement {
    constructor () {
      super();
  
      this.someMethod = true;
    }
  }
  
  if (!customElements.get('any-class')) {
    customElements.define('any-class', AnyClass, {
      extends: 'br'
    });
  }
  
  // support build-in custom element
  // so return
  const isSupportBuildIn = document.createElement('br', {
    is: 'any-class'
  }).someMethod;
  
  // https://github.com/WebReflection/custom-elements-builtin
  (function () {
    'use strict';
  
    if (isSupportBuildIn) {
      return;
    }
  
    var attributesObserver = (whenDefined, MutationObserver) => {
  
      const attributeChanged = records => {
        for (let i = 0, {length} = records; i < length; i++)
          dispatch(records[i]);
      };
  
      const dispatch = ({target, attributeName, oldValue}) => {
        target.attributeChangedCallback(
          attributeName,
          oldValue,
          target.getAttribute(attributeName)
        );
      };
  
      return (target, is) => {
        const {observedAttributes: attributeFilter} = target.constructor;
        if (attributeFilter) {
          whenDefined(is).then(() => {
            new MutationObserver(attributeChanged).observe(target, {
              attributes: true,
              attributeOldValue: true,
              attributeFilter
            });
            for (let i = 0, {length} = attributeFilter; i < length; i++) {
              if (target.hasAttribute(attributeFilter[i]))
                dispatch({target, attributeName: attributeFilter[i], oldValue: null});
            }
          });
        }
        return target;
      };
    };
  
    const {keys} = Object;
  
    const expando = element => {
      const key = keys(element);
      const value = [];
      const {length} = key;
      for (let i = 0; i < length; i++) {
        value[i] = element[key[i]];
        delete element[key[i]];
      }
      return () => {
        for (let i = 0; i < length; i++)
          element[key[i]] = value[i];
      };
    };
  
    const {document, MutationObserver, Set, WeakMap} = self;
  
    const elements = element => 'querySelectorAll' in element;
    const {filter} = [];
  
    var qsaObserver = options => {
      const live = new WeakMap;
      const callback = records => {
        const {query} = options;
        if (query.length) {
          for (let i = 0, {length} = records; i < length; i++) {
            loop(filter.call(records[i].addedNodes, elements), true, query);
            loop(filter.call(records[i].removedNodes, elements), false, query);
          }
        }
      };
      const drop = elements => {
        for (let i = 0, {length} = elements; i < length; i++)
          live.delete(elements[i]);
      };
      const flush = () => {
        callback(observer.takeRecords());
      };
      const loop = (elements, connected, query, set = new Set) => {
        for (let selectors, element, i = 0, {length} = elements; i < length; i++) {
          // guard against repeated elements within nested querySelectorAll results
          if (!set.has(element = elements[i])) {
            set.add(element);
            if (connected) {
              for (let q, m = matches(element), i = 0, {length} = query; i < length; i++) {
                if (m.call(element, q = query[i])) {
                  if (!live.has(element))
                    live.set(element, new Set);
                  selectors = live.get(element);
                  // guard against selectors that were handled already
                  if (!selectors.has(q)) {
                    selectors.add(q);
                    options.handle(element, connected, q);
                  }
                }
              }
            }
            // guard against elements that never became live
            else if (live.has(element)) {
              selectors = live.get(element);
              live.delete(element);
              selectors.forEach(q => {
                options.handle(element, connected, q);
              });
            }
            loop(querySelectorAll(element), connected, query, set);
          }
        }
      };
      const matches = element => (
        element.matches ||
        element.webkitMatchesSelector ||
        element.msMatchesSelector
      );
      const parse = (elements, connected = true) => {
        loop(elements, connected, options.query);
      };
      const querySelectorAll = root => query.length ?
                                root.querySelectorAll(query) : query;
      const observer = new MutationObserver(callback);
      const root = options.root || document;
      const {query} = options;
      observer.observe(root, {childList: true, subtree: true});
      parse(querySelectorAll(root));
      return {drop, flush, observer, parse};
    };
  
    const {
      customElements, document: document$1,
      Element, MutationObserver: MutationObserver$1, Object: Object$1, Promise,
      Map, Set: Set$1, WeakMap: WeakMap$1, Reflect
    } = self;
  
    const {attachShadow} = Element.prototype;
    const {createElement} = document$1;
    const {define, get} = customElements;
    const {construct} = Reflect || {construct(HTMLElement) {
      return HTMLElement.call(this);
    }};
  
    const {defineProperty, keys: keys$1, getOwnPropertyNames, setPrototypeOf} = Object$1;
  
    const shadowRoots = new WeakMap$1;
    const shadows = new Set$1;
  
    const classes = new Map;
    const defined = new Map;
    const prototypes = new Map;
    const registry = new Map;
  
    const shadowed = [];
    const query = [];
  
    const getCE = is => registry.get(is) || get.call(customElements, is);
  
    const handle = (element, connected, selector) => {
      const proto = prototypes.get(selector);
      if (connected && !proto.isPrototypeOf(element)) {
        const redefine = expando(element);
        override = setPrototypeOf(element, proto);
        try { new proto.constructor; }
        finally {
          override = null;
          redefine();
        }
      }
      const method = `${connected ? '' : 'dis'}connectedCallback`;
      if (method in proto)
        element[method]();
    };
  
    const {parse} = qsaObserver({query, handle});
  
    const {parse: parseShadowed} = qsaObserver({
      query: shadowed,
      handle(element, connected) {
        if (shadowRoots.has(element)) {
          if (connected)
            shadows.add(element);
          else
            shadows.delete(element);
          if (query.length)
            parseShadow.call(query, element);
        }
      }
    });
  
    const whenDefined = name => {
      if (!defined.has(name)) {
        let _, $ = new Promise($ => { _ = $; });
        defined.set(name, {$, _});
      }
      return defined.get(name).$;
    };
  
    const augment = attributesObserver(whenDefined, MutationObserver$1);
  
    let override = null;
  
    getOwnPropertyNames(self)
      .filter(k => /^HTML/.test(k))
      .forEach(k => {
        const HTMLElement = self[k];
        function HTMLBuiltIn() {
          const {constructor} = this;
          if (!classes.has(constructor))
            throw new TypeError('Illegal constructor');
          const {is, tag} = classes.get(constructor);
          if (is) {
            if (override)
              return augment(override, is);
            const element = createElement.call(document$1, tag);
            element.setAttribute('is', is);
            return augment(setPrototypeOf(element, constructor.prototype), is);
          }
          else
            return construct.call(this, HTMLElement, [], constructor);
        }
        setPrototypeOf(HTMLBuiltIn, HTMLElement);
        defineProperty(
          HTMLBuiltIn.prototype = HTMLElement.prototype,
          'constructor',
          {value: HTMLBuiltIn}
        );
        defineProperty(self, k, {value: HTMLBuiltIn});
      });
  
    defineProperty(document$1, 'createElement', {
      configurable: true,
      value(name, options) {
        const is = options && options.is;
        if (is) {
          const Class = registry.get(is);
          if (Class && classes.get(Class).tag === name)
            return new Class;
        }
        const element = createElement.call(document$1, name);
        if (is)
          element.setAttribute('is', is);
        return element;
      }
    });
  
    if (attachShadow)
      defineProperty(Element.prototype, 'attachShadow', {
        configurable: true,
        value() {
          const root = attachShadow.apply(this, arguments);
          const {parse} = qsaObserver({query, root, handle});
          shadowRoots.set(this, {root, parse});
          return root;
        }
      });
  
    defineProperty(customElements, 'get', {
      configurable: true,
      value: getCE
    });
  
    defineProperty(customElements, 'whenDefined', {
      configurable: true,
      value: whenDefined
    });
  
    defineProperty(customElements, 'define', {
      configurable: true,
      value(is, Class, options) {
        if (getCE(is))
          throw new Error(`'${is}' has already been defined as a custom element`);
        let selector;
        const tag = options && options.extends;
        classes.set(Class, tag ? {is, tag} : {is: '', tag: is});
        if (tag) {
          selector = `${tag}[is="${is}"]`;
          prototypes.set(selector, Class.prototype);
          registry.set(is, Class);
          query.push(selector);
        }
        else {
          define.apply(customElements, arguments);
          shadowed.push(selector = is);
        }
        whenDefined(is).then(() => {
          if (tag) {
            parse(document$1.querySelectorAll(selector));
            shadows.forEach(parseShadow, [selector]);
          }
          else
            parseShadowed(document$1.querySelectorAll(selector));
        });
        defined.get(is)._(Class);
      }
    });
  
    function parseShadow(element) {
      const {parse, root} = shadowRoots.get(element);
      parse(root.querySelectorAll(this), element.isConnected);
    }
  
  }());
  